TypeScript Generics: Paplašināti Lietošanas Modeļi

TypeScript generics ir spēcīga funkcija, kas ļauj rakstīt elastīgāku, atkārtoti lietojamu un tipu drošu kodu. Tie ļauj definēt tipus, kas var strādāt ar dažādiem citiem tipiem, vienlaikus saglabājot tipu pārbaudi kompilācijas laikā. Šis emuāra ieraksts iedziļinās paplašinātos lietošanas modeļos, sniedzot praktiskus piemērus un ieskatus visu līmeņu izstrādātājiem, neatkarīgi no viņu ģeogrāfiskās atrašanās vietas vai izcelsmes.

Pamatu Izpratne: Atkārtojums

Pirms iedziļināties paplašinātās tēmās, ātri atkārtosim pamatus. Generics ļauj izveidot komponentes, kas var strādāt ar dažādiem tipiem, nevis tikai ar vienu tipu. Jūs deklarējat vispārīgo tipa parametru leņķa iekavās (`<>`) pēc funkcijas vai klases nosaukuma. Šis parametrs darbojas kā vietturis faktiskajam tipam, kas tiks norādīts vēlāk, kad funkcija vai klase tiks izmantota.

Piemēram, vienkārša vispārīgā funkcija varētu izskatīties šādi:

            function identity(arg: T): T {
  return arg;
}

            

              
                Copy
              
            
          

Šajā piemērā T ir vispārīgais tipa parametrs. Funkcija identity pieņem argumentu ar tipu T un atgriež vērtību ar tipu T. Pēc tam šo funkciju var izsaukt ar dažādiem tipiem:

            
let stringResult: string = identity("hello");
let numberResult: number = identity(42);

            

              
                Copy
              
            
          

Paplašināti Generics: Vairāk nekā Pamati

Tagad izpētīsim sarežģītākus veidus, kā izmantot generics.

1. Vispārīgo Tipu Ierobežojumi

Tipu ierobežojumi ļauj ierobežot tipus, kurus var izmantot ar vispārīgo tipa parametru. Tas ir būtiski, kad jums ir jānodrošina, ka vispārīgajam tipam ir noteiktas īpašības vai metodes. Lai norādītu ierobežojumu, varat izmantot atslēgvārdu extends.

Apsveriet piemēru, kur vēlaties, lai funkcija piekļūtu length īpašībai:

            function loggingIdentity(arg: T): T {
  console.log(arg.length);
  return arg;
}

            

              
                Copy
              
            
          

Šajā piemērā T ir ierobežots ar tipiem, kuriem ir length īpašība ar tipu number. Tas ļauj mums droši piekļūt arg.length. Mēģinot nodot tipu, kas neatbilst šim ierobežojumam, radīsies kompilācijas laika kļūda.

Globāls Pielietojums: Tas ir īpaši noderīgi scenārijos, kas saistīti ar datu apstrādi, piemēram, strādājot ar masīviem vai virknēm, kur bieži ir nepieciešams zināt garumu. Šis modelis darbojas vienādi neatkarīgi no tā, vai atrodaties Tokijā, Londonā vai Riodežaneiro.

2. Generics Izmantošana ar Saskarnēm

Generics nevainojami darbojas ar saskarnēm, ļaujot definēt elastīgas un atkārtoti lietojamas saskarņu definīcijas.

            interface GenericIdentityFn {
  (arg: T): T;
}

function identity(arg: T): T {
  return arg;
}

let myIdentity: GenericIdentityFn = identity;

            

              
                Copy
              
            
          

Šeit GenericIdentityFn ir saskarne, kas apraksta funkciju, kura pieņem vispārīgo tipu T un atgriež to pašu tipu T. Tas ļauj definēt funkcijas ar dažādiem tipu parakstiem, saglabājot tipu drošību.

Globālā Perspektīva: Šis modelis ļauj izveidot atkārtoti lietojamas saskarnes dažādu veidu objektiem. Piemēram, varat izveidot vispārīgu saskarni datu pārsūtīšanas objektiem (DTO), ko izmanto dažādās API, nodrošinot konsekventas datu struktūras visā jūsu lietojumprogrammā neatkarīgi no reģiona, kurā tā tiek ieviesta.

3. Vispārīgās Klases

Arī klases var būt vispārīgas:

            
class GenericNumber {
  zeroValue: T;
  add: (x: T, y: T) => T;
}

let myGenericNumber = new GenericNumber();
myGenericNumber.zeroValue = 0;
myGenericNumber.add = function(x, y) { return x + y; };

            

              
                Copy
              
            
          

Šī klase GenericNumber var saturēt vērtību ar tipu T un definēt add metodi, kas darbojas ar tipu T. Jūs instancējat klasi ar vēlamo tipu. Tas var būt ļoti noderīgi, veidojot datu struktūras, piemēram, stekus vai rindas.

Globāls Pielietojums: Iedomājieties finanšu lietojumprogrammu, kurai nepieciešams uzglabāt un apstrādāt dažādas valūtas (piem., USD, EUR, JPY). Jūs varētu izmantot vispārīgu klasi, lai izveidotu CurrencyAmount klasi, kur T apzīmē valūtas tipu, ļaujot veikt tipu drošus aprēķinus un uzglabāt dažādu valūtu summas.

4. Vairāki Tipu Parametri

Generics var izmantot vairākus tipu parametrus:

            
function swap(a: T, b: U): [U, T] {
  return [b, a];
}

let result = swap("hello", 42);
// result[0] is number, result[1] is string

            

              
                Copy
              
            
          

Funkcija swap pieņem divus argumentus ar dažādiem tipiem un atgriež kortežu ar samainītiem tipiem.

Globālā Nozīme: Starptautiskās biznesa lietojumprogrammās jums varētu būt funkcija, kas pieņem divus saistītus datu gabalus ar dažādiem tipiem un atgriež to kortežu, piemēram, klienta ID (virkne) un pasūtījuma vērtība (skaitlis). Šis modelis nedod priekšroku nevienai konkrētai valstij un lieliski pielāgojas globālajām vajadzībām.

5. Tipu Parametru Izmantošana Vispārīgajos Ierobežojumos

Jūs varat izmantot tipa parametru ierobežojuma ietvaros.

            
function getProperty(obj: T, key: K) {
  return obj[key];
}

let obj = { a: 1, b: 2, c: 3 };

let value = getProperty(obj, "a"); // value is number

            

              
                Copy
              
            
          

Šajā piemērā K extends keyof T nozīmē, ka K var būt tikai tipa T atslēga. Tas nodrošina spēcīgu tipu drošību, dinamiski piekļūstot objektu īpašībām.

Globālā Pielietojamība: Tas ir īpaši noderīgi, strādājot ar konfigurācijas objektiem vai datu struktūrām, kur īpašību piekļuve ir jāvalidē izstrādes laikā. Šo tehniku var pielietot lietojumprogrammās jebkurā valstī.

6. Vispārīgie Utilīttipi

TypeScript nodrošina vairākus iebūvētus utilīttipus, kas izmanto generics, lai veiktu bieži sastopamas tipu transformācijas. Tie ietver:

• Partial: Padara visas T īpašības par izvēles (optional).
• Required: Padara visas T īpašības par obligātām.
• Readonly: Padara visas T īpašības par tikai lasāmām.
• Pick: Atlasa īpašību kopu no T.
• Omit: Noņem īpašību kopu no T.

Piemēram:

            
interface User {
  id: number;
  name: string;
  email: string;
}

// Partial - all properties optional
let optionalUser: Partial = {};

// Pick - only id and name properties
let userSummary: Pick = { id: 1, name: 'John' };

            

              
                Copy
              
            
          

Globāls Lietošanas Gadījums: Šie utilīti ir nenovērtējami, veidojot API pieprasījumu un atbilžu modeļus. Piemēram, globālā e-komercijas lietojumprogrammā Partial var izmantot, lai attēlotu atjaunināšanas pieprasījumu (kur tiek nosūtīta tikai daļa produkta informācijas), savukārt Readonly varētu attēlot produktu, kas tiek parādīts lietotāja saskarnē.

7. Tipu Secināšana ar Generics

TypeScript bieži var secināt tipu parametrus, pamatojoties uz argumentiem, ko nododat vispārīgai funkcijai vai klasei. Tas var padarīt jūsu kodu tīrāku un vieglāk lasāmu.

            
function createPair(a: T, b: T): [T, T] {
  return [a, b];
}

let pair = createPair("hello", "world"); // TypeScript infers T as string

            

              
                Copy
              
            
          

Šajā gadījumā TypeScript automātiski secina, ka T ir string, jo abi argumenti ir virknes.

Globālā Ietekme: Tipu secināšana samazina nepieciešamību pēc skaidrām tipu anotācijām, kas var padarīt jūsu kodu kodolīgāku un lasāmāku. Tas uzlabo sadarbību starp dažādām izstrādes komandām, kurās var būt dažādi pieredzes līmeņi.

8. Nosacījuma Tipi ar Generics

Nosacījuma tipi kopā ar generics nodrošina spēcīgu veidu, kā izveidot tipus, kas ir atkarīgi no citu tipu vērtībām.

            
type Check = T extends string ? string : number;

let result1: Check = "hello"; // string
let result2: Check = 42; // number

            

              
                Copy
              
            
          

Šajā piemērā Check tiek novērtēts kā string, ja T paplašina string, pretējā gadījumā tas tiek novērtēts kā number.

Globālais Konteksts: Nosacījuma tipi ir ārkārtīgi noderīgi, lai dinamiski veidotu tipus, pamatojoties uz noteiktiem nosacījumiem. Iedomājieties sistēmu, kas apstrādā datus, pamatojoties uz reģionu. Nosacījuma tipus var izmantot, lai pārveidotu datus, pamatojoties uz reģionam specifiskiem datu formātiem vai datu tipiem. Tas ir būtiski lietojumprogrammām ar globālām datu pārvaldības prasībām.

9. Generics Izmantošana ar Kartētajiem Tipiem

Kartētie tipi ļauj pārveidot tipa īpašības, pamatojoties uz citu tipu. Apvienojiet tos ar generics, lai iegūtu elastību:

            
type OptionsFlags = {
  [K in keyof T]: boolean;
};

interface FeatureFlags {
  darkMode: boolean;
  notifications: boolean;
}

// Create a type where each feature flag is enabled (true) or disabled (false)
let featureFlags: OptionsFlags = {
  darkMode: true,
  notifications: false,
};

            

              
                Copy
              
            
          

Tips OptionsFlags pieņem vispārīgo tipu T un izveido jaunu tipu, kurā T īpašības tagad ir kartētas uz Būla vērtībām. Tas ir ļoti spēcīgs rīks, strādājot ar konfigurācijām vai funkciju karodziņiem (feature flags).

Globāls Pielietojums: Šis modelis ļauj veidot konfigurācijas shēmas, pamatojoties uz reģionam specifiskiem iestatījumiem. Šī pieeja ļauj izstrādātājiem definēt reģionam specifiskas konfigurācijas (piemēram, valodas, kas tiek atbalstītas reģionā). Tas ļauj viegli izveidot un uzturēt globālas lietojumprogrammu konfigurācijas shēmas.

10. Paplašināta Secināšana ar Atslēgvārdu `infer`

Atslēgvārds infer ļauj iegūt tipus no citiem tipiem nosacījuma tipu ietvaros.

            
type ReturnType any> = T extends (...args: any) => infer R ? R : any;

function myFunction(): string {
  return "hello";
}

let result: ReturnType = "hello"; // result is string

            

              
                Copy
              
            
          

Šis piemērs secina funkcijas atgriešanas tipu, izmantojot atslēgvārdu infer. Tā ir sarežģīta tehnika progresīvākai tipu manipulācijai.

Globālā Nozīme: Šī tehnika var būt vitāli svarīga lielos, izkliedētos globālos programmatūras projektos, lai nodrošinātu tipu drošību, strādājot ar sarežģītiem funkciju parakstiem un sarežģītām datu struktūrām. Tā ļauj dinamiski ģenerēt tipus no citiem tipiem, uzlabojot koda uzturējamību.

Labākā Prakse un Padomi

• Izmantojiet jēgpilnus nosaukumus: Izvēlieties aprakstošus nosaukumus saviem vispārīgajiem tipu parametriem (piem., TValue, TKey), lai uzlabotu lasāmību.
• Dokumentējiet savus generics: Izmantojiet JSDoc komentārus, lai izskaidrotu savu vispārīgo tipu un ierobežojumu mērķi. Tas ir būtiski komandas sadarbībai, īpaši ar komandām, kas izvietotas visā pasaulē.
• Saglabājiet vienkāršību: Izvairieties no pārmērīgas generics inženierijas. Sāciet ar vienkāršiem risinājumiem un pārveidojiet tos, mainoties jūsu vajadzībām. Pārāk liela sarežģītība var apgrūtināt izpratni dažiem komandas locekļiem.
• Apsveriet tvērumu: Rūpīgi apsveriet savu vispārīgo tipu parametru tvērumu. Tiem jābūt pēc iespējas šaurākiem, lai izvairītos no neparedzētām tipu neatbilstībām.
• Izmantojiet esošos utilīttipus: Kad vien iespējams, izmantojiet TypeScript iebūvētos utilīttipus. Tie var ietaupīt jūsu laiku un pūles.
• Rūpīgi testējiet: Rakstiet visaptverošus vienībtestus, lai nodrošinātu, ka jūsu vispārīgais kods darbojas, kā paredzēts ar dažādiem tipiem.

Nobeigums: Generics Spēka Pieņemšana Globāli

TypeScript generics ir stūrakmens robusta un uzturama koda rakstīšanā. Apgūstot šos paplašinātos modeļus, jūs varat ievērojami uzlabot tipu drošību, atkārtotu lietojamību un kopējo kvalitāti savās JavaScript lietojumprogrammās. No vienkāršiem tipu ierobežojumiem līdz sarežģītiem nosacījuma tipiem, generics nodrošina rīkus, kas nepieciešami, lai veidotu mērogojamu un uzturamu programmatūru globālai auditorijai. Atcerieties, ka generics lietošanas principi paliek nemainīgi neatkarīgi no jūsu ģeogrāfiskās atrašanās vietas.

Pielietojot šajā rakstā apspriestās tehnikas, jūs varat izveidot labāk strukturētu, uzticamāku un viegli paplašināmu kodu, kas galu galā noved pie veiksmīgākiem programmatūras projektiem neatkarīgi no valsts, kontinenta vai biznesa, ar kuru esat saistīts. Pieņemiet generics, un jūsu kods jums pateiksies!